home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Linux / SLAX 6.0.8 / slax-6.0.8.iso / slax / base / 006-devel.lzm / usr / include / ext2fs / ext2fs.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-10-18  |  41.9 KB  |  1,374 lines
  1. /*
  2.  * ext2fs.h --- ext2fs
  3.  *
  4.  * Copyright (C) 1993, 1994, 1995, 1996 Theodore Ts'o.
  5.  *
  6.  * %Begin-Header%
  7.  * This file may be redistributed under the terms of the GNU Public
  8.  * License.
  9.  * %End-Header%
  10.  */
  11.  
  12. #ifndef _EXT2FS_EXT2FS_H
  13. #define _EXT2FS_EXT2FS_H
  14.  
  15. #ifdef __GNUC__
  16. #define EXT2FS_ATTR(x) __attribute__(x)
  17. #else
  18. #define EXT2FS_ATTR(x)
  19. #endif
  20.  
  21. #ifdef __cplusplus
  22. extern "C" {
  23. #endif
  24.  
  25. /*
  26.  * Non-GNU C compilers won't necessarily understand inline
  27.  */
  28. #if (!defined(__GNUC__) && !defined(__WATCOMC__))
  29. #define NO_INLINE_FUNCS
  30. #endif
  31.  
  32. /*
  33.  * Where the master copy of the superblock is located, and how big
  34.  * superblocks are supposed to be.  We define SUPERBLOCK_SIZE because
  35.  * the size of the superblock structure is not necessarily trustworthy
  36.  * (some versions have the padding set up so that the superblock is
  37.  * 1032 bytes long).
  38.  */
  39. #define SUPERBLOCK_OFFSET    1024
  40. #define SUPERBLOCK_SIZE     1024
  41.  
  42. /*
  43.  * The last ext2fs revision level that this version of the library is
  44.  * able to support.
  45.  */
  46. #define EXT2_LIB_CURRENT_REV    EXT2_DYNAMIC_REV
  47.  
  48. #ifdef HAVE_SYS_TYPES_H
  49. #include <sys/types.h>
  50. #endif
  51.  
  52. #include <stdio.h>
  53. #include <stdlib.h>
  54. #include <string.h>
  55.  
  56. #if EXT2_FLAT_INCLUDES
  57. #include "e2_types.h"
  58. #include "ext2_fs.h"
  59. #include "ext3_extents.h"
  60. #else
  61. #include <ext2fs/ext2_types.h>
  62. #include <ext2fs/ext2_fs.h>
  63. #include <ext2fs/ext3_extents.h>
  64. #endif /* EXT2_FLAT_INCLUDES */
  65.  
  66. typedef __u32        ext2_ino_t;
  67. typedef __u32        blk_t;
  68. typedef __u64        blk64_t;
  69. typedef __u32        dgrp_t;
  70. typedef __u32        ext2_off_t;
  71. typedef __s64        e2_blkcnt_t;
  72. typedef __u32        ext2_dirhash_t;
  73.  
  74. #if EXT2_FLAT_INCLUDES
  75. #include "com_err.h"
  76. #include "ext2_io.h"
  77. #include "ext2_err.h"
  78. #include "ext2_ext_attr.h"
  79. #else
  80. #include <et/com_err.h>
  81. #include <ext2fs/ext2_io.h>
  82. #include <ext2fs/ext2_err.h>
  83. #include <ext2fs/ext2_ext_attr.h>
  84. #endif
  85.  
  86. /*
  87.  * Portability help for Microsoft Visual C++
  88.  */
  89. #ifdef _MSC_VER
  90. #define EXT2_QSORT_TYPE int __cdecl
  91. #else
  92. #define EXT2_QSORT_TYPE int
  93. #endif
  94.  
  95. typedef struct struct_ext2_filsys *ext2_filsys;
  96.  
  97. #define EXT2FS_MARK_ERROR     0
  98. #define EXT2FS_UNMARK_ERROR     1
  99. #define EXT2FS_TEST_ERROR    2
  100.  
  101. typedef struct ext2fs_struct_generic_bitmap *ext2fs_generic_bitmap;
  102. typedef struct ext2fs_struct_generic_bitmap *ext2fs_inode_bitmap;
  103. typedef struct ext2fs_struct_generic_bitmap *ext2fs_block_bitmap;
  104.  
  105. #define EXT2_FIRST_INODE(s)    EXT2_FIRST_INO(s)
  106.  
  107.  
  108. /*
  109.  * Badblocks list definitions
  110.  */
  111.  
  112. typedef struct ext2_struct_u32_list *ext2_badblocks_list;
  113. typedef struct ext2_struct_u32_iterate *ext2_badblocks_iterate;
  114.  
  115. typedef struct ext2_struct_u32_list *ext2_u32_list;
  116. typedef struct ext2_struct_u32_iterate *ext2_u32_iterate;
  117.  
  118. /* old */
  119. typedef struct ext2_struct_u32_list *badblocks_list;
  120. typedef struct ext2_struct_u32_iterate *badblocks_iterate;
  121.  
  122. #define BADBLOCKS_FLAG_DIRTY    1
  123.  
  124. /*
  125.  * ext2_dblist structure and abstractions (see dblist.c)
  126.  */
  127. struct ext2_db_entry {
  128.     ext2_ino_t    ino;
  129.     blk_t    blk;
  130.     int    blockcnt;
  131. };
  132.  
  133. typedef struct ext2_struct_dblist *ext2_dblist;
  134.  
  135. #define DBLIST_ABORT    1
  136.  
  137. /*
  138.  * ext2_fileio definitions
  139.  */
  140.  
  141. #define EXT2_FILE_WRITE        0x0001
  142. #define EXT2_FILE_CREATE    0x0002
  143.  
  144. #define EXT2_FILE_MASK        0x00FF
  145.  
  146. #define EXT2_FILE_BUF_DIRTY    0x4000
  147. #define EXT2_FILE_BUF_VALID    0x2000
  148.  
  149. typedef struct ext2_file *ext2_file_t;
  150.  
  151. #define EXT2_SEEK_SET    0
  152. #define EXT2_SEEK_CUR    1
  153. #define EXT2_SEEK_END    2
  154.  
  155. /*
  156.  * Flags for the ext2_filsys structure and for ext2fs_open()
  157.  */
  158. #define EXT2_FLAG_RW            0x01
  159. #define EXT2_FLAG_CHANGED        0x02
  160. #define EXT2_FLAG_DIRTY            0x04
  161. #define EXT2_FLAG_VALID            0x08
  162. #define EXT2_FLAG_IB_DIRTY        0x10
  163. #define EXT2_FLAG_BB_DIRTY        0x20
  164. #define EXT2_FLAG_SWAP_BYTES        0x40
  165. #define EXT2_FLAG_SWAP_BYTES_READ    0x80
  166. #define EXT2_FLAG_SWAP_BYTES_WRITE    0x100
  167. #define EXT2_FLAG_MASTER_SB_ONLY    0x200
  168. #define EXT2_FLAG_FORCE            0x400
  169. #define EXT2_FLAG_SUPER_ONLY        0x800
  170. #define EXT2_FLAG_JOURNAL_DEV_OK    0x1000
  171. #define EXT2_FLAG_IMAGE_FILE        0x2000
  172. #define EXT2_FLAG_EXCLUSIVE        0x4000
  173. #define EXT2_FLAG_SOFTSUPP_FEATURES    0x8000
  174. #define EXT2_FLAG_NOFREE_ON_ERROR    0x10000
  175.  
  176. /*
  177.  * Special flag in the ext2 inode i_flag field that means that this is
  178.  * a new inode.  (So that ext2_write_inode() can clear extra fields.)
  179.  */
  180. #define EXT2_NEW_INODE_FL    0x80000000
  181.  
  182. /*
  183.  * Flags for mkjournal
  184.  *
  185.  * EXT2_MKJOURNAL_V1_SUPER    Make a (deprecated) V1 journal superblock
  186.  */
  187. #define EXT2_MKJOURNAL_V1_SUPER    0x0000001
  188.  
  189. struct struct_ext2_filsys {
  190.     errcode_t            magic;
  191.     io_channel            io;
  192.     int                flags;
  193.     char *                device_name;
  194.     struct ext2_super_block    *     super;
  195.     unsigned int            blocksize;
  196.     int                fragsize;
  197.     dgrp_t                group_desc_count;
  198.     unsigned long            desc_blocks;
  199.     struct ext2_group_desc *    group_desc;
  200.     int                inode_blocks_per_group;
  201.     ext2fs_inode_bitmap        inode_map;
  202.     ext2fs_block_bitmap        block_map;
  203.     errcode_t (*get_blocks)(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks);
  204.     errcode_t (*check_directory)(ext2_filsys fs, ext2_ino_t ino);
  205.     errcode_t (*write_bitmaps)(ext2_filsys fs);
  206.     errcode_t (*read_inode)(ext2_filsys fs, ext2_ino_t ino,
  207.                 struct ext2_inode *inode);
  208.     errcode_t (*write_inode)(ext2_filsys fs, ext2_ino_t ino,
  209.                 struct ext2_inode *inode);
  210.     ext2_badblocks_list        badblocks;
  211.     ext2_dblist            dblist;
  212.     __u32                stride;    /* for mke2fs */
  213.     struct ext2_super_block *    orig_super;
  214.     struct ext2_image_hdr *        image_header;
  215.     __u32                umask;
  216.     time_t                now;
  217.     /*
  218.      * Reserved for future expansion
  219.      */
  220.     __u32                reserved[7];
  221.  
  222.     /*
  223.      * Reserved for the use of the calling application.
  224.      */
  225.     void *                priv_data;
  226.  
  227.     /*
  228.      * Inode cache
  229.      */
  230.     struct ext2_inode_cache        *icache;
  231.     io_channel            image_io;
  232.  
  233.     /*
  234.      * More callback functions
  235.      */
  236.     errcode_t (*get_alloc_block)(ext2_filsys fs, blk64_t goal,
  237.                      blk64_t *ret);
  238.     void (*block_alloc_stats)(ext2_filsys fs, blk64_t blk, int inuse);
  239. };
  240.  
  241. #if EXT2_FLAT_INCLUDES
  242. #include "e2_bitops.h"
  243. #else
  244. #include <ext2fs/bitops.h>
  245. #endif
  246.  
  247. /*
  248.  * Return flags for the block iterator functions
  249.  */
  250. #define BLOCK_CHANGED    1
  251. #define BLOCK_ABORT    2
  252. #define BLOCK_ERROR    4
  253.  
  254. /*
  255.  * Block interate flags
  256.  *
  257.  * BLOCK_FLAG_APPEND, or BLOCK_FLAG_HOLE, indicates that the interator
  258.  * function should be called on blocks where the block number is zero.
  259.  * This is used by ext2fs_expand_dir() to be able to add a new block
  260.  * to an inode.  It can also be used for programs that want to be able
  261.  * to deal with files that contain "holes".
  262.  *
  263.  * BLOCK_FLAG_DEPTH_TRAVERSE indicates that the iterator function for
  264.  * the indirect, doubly indirect, etc. blocks should be called after
  265.  * all of the blocks containined in the indirect blocks are processed.
  266.  * This is useful if you are going to be deallocating blocks from an
  267.  * inode.
  268.  *
  269.  * BLOCK_FLAG_DATA_ONLY indicates that the iterator function should be
  270.  * called for data blocks only.
  271.  *
  272.  * BLOCK_FLAG_READ_ONLY is a promise by the caller that it will not
  273.  * modify returned block number.
  274.  *
  275.  * BLOCK_FLAG_NO_LARGE is for internal use only.  It informs
  276.  * ext2fs_block_iterate2 that large files won't be accepted.
  277.  */
  278. #define BLOCK_FLAG_APPEND    1
  279. #define BLOCK_FLAG_HOLE        1
  280. #define BLOCK_FLAG_DEPTH_TRAVERSE    2
  281. #define BLOCK_FLAG_DATA_ONLY    4
  282. #define BLOCK_FLAG_READ_ONLY    8
  283.  
  284. #define BLOCK_FLAG_NO_LARGE    0x1000
  285.  
  286. /*
  287.  * Magic "block count" return values for the block iterator function.
  288.  */
  289. #define BLOCK_COUNT_IND        (-1)
  290. #define BLOCK_COUNT_DIND    (-2)
  291. #define BLOCK_COUNT_TIND    (-3)
  292. #define BLOCK_COUNT_TRANSLATOR    (-4)
  293.  
  294. #if 0
  295. /*
  296.  * Flags for ext2fs_move_blocks
  297.  */
  298. #define EXT2_BMOVE_GET_DBLIST    0x0001
  299. #define EXT2_BMOVE_DEBUG    0x0002
  300. #endif
  301.  
  302. /*
  303.  * Generic (non-filesystem layout specific) extents structure
  304.  */
  305.  
  306. #define EXT2_EXTENT_FLAGS_LEAF        0x0001
  307. #define EXT2_EXTENT_FLAGS_UNINIT    0x0002
  308. #define EXT2_EXTENT_FLAGS_SECOND_VISIT    0x0004
  309.  
  310. struct ext2fs_extent {
  311.     blk64_t    e_pblk;        /* first physical block */
  312.     blk64_t    e_lblk;        /* first logical block extent covers */
  313.     __u32    e_len;        /* number of blocks covered by extent */
  314.     __u32    e_flags;    /* extent flags */
  315. };
  316.  
  317. typedef struct ext2_extent_handle *ext2_extent_handle_t;
  318. typedef struct ext2_extent_path *ext2_extent_path_t;
  319.  
  320. /*
  321.  * Flags used by ext2fs_extent_get()
  322.  */
  323. #define EXT2_EXTENT_CURRENT    0x0000
  324. #define EXT2_EXTENT_MOVE_MASK    0x000F
  325. #define EXT2_EXTENT_ROOT    0x0001
  326. #define EXT2_EXTENT_LAST_LEAF    0x0002
  327. #define EXT2_EXTENT_FIRST_SIB    0x0003
  328. #define EXT2_EXTENT_LAST_SIB    0x0004
  329. #define EXT2_EXTENT_NEXT_SIB    0x0005
  330. #define EXT2_EXTENT_PREV_SIB    0x0006
  331. #define EXT2_EXTENT_NEXT_LEAF    0x0007
  332. #define EXT2_EXTENT_PREV_LEAF    0x0008
  333. #define EXT2_EXTENT_NEXT    0x0009
  334. #define EXT2_EXTENT_PREV    0x000A
  335. #define EXT2_EXTENT_UP        0x000B
  336. #define EXT2_EXTENT_DOWN    0x000C
  337. #define EXT2_EXTENT_DOWN_AND_LAST 0x000D
  338.  
  339. /*
  340.  * Flags used by ext2fs_extent_insert()
  341.  */
  342. #define EXT2_EXTENT_INSERT_AFTER    0x0001 /* insert after handle loc'n */
  343. #define EXT2_EXTENT_INSERT_NOSPLIT    0x0002 /* insert may not cause split */
  344.  
  345. /*
  346.  * Flags used by ext2fs_extent_delete()
  347.  */
  348. #define EXT2_EXTENT_DELETE_KEEP_EMPTY    0x001 /* keep node if last extnt gone */
  349.  
  350. /*
  351.  * Flags used by ext2fs_extent_set_bmap()
  352.  */
  353. #define EXT2_EXTENT_SET_BMAP_UNINIT    0x0001
  354.  
  355. /*
  356.  * Data structure returned by ext2fs_extent_get_info()
  357.  */
  358. struct ext2_extent_info {
  359.     int        curr_entry;
  360.     int        curr_level;
  361.     int        num_entries;
  362.     int        max_entries;
  363.     int        max_depth;
  364.     int        bytes_avail;
  365.     blk64_t        max_lblk;
  366.     blk64_t        max_pblk;
  367.     __u32        max_len;
  368.     __u32        max_uninit_len;
  369. };
  370.  
  371. /*
  372.  * Flags for directory block reading and writing functions
  373.  */
  374. #define EXT2_DIRBLOCK_V2_STRUCT    0x0001
  375.  
  376. /*
  377.  * Return flags for the directory iterator functions
  378.  */
  379. #define DIRENT_CHANGED    1
  380. #define DIRENT_ABORT    2
  381. #define DIRENT_ERROR    3
  382.  
  383. /*
  384.  * Directory iterator flags
  385.  */
  386.  
  387. #define DIRENT_FLAG_INCLUDE_EMPTY    1
  388. #define DIRENT_FLAG_INCLUDE_REMOVED    2
  389.  
  390. #define DIRENT_DOT_FILE        1
  391. #define DIRENT_DOT_DOT_FILE    2
  392. #define DIRENT_OTHER_FILE    3
  393. #define DIRENT_DELETED_FILE    4
  394.  
  395. /*
  396.  * Inode scan definitions
  397.  */
  398. typedef struct ext2_struct_inode_scan *ext2_inode_scan;
  399.  
  400. /*
  401.  * ext2fs_scan flags
  402.  */
  403. #define EXT2_SF_CHK_BADBLOCKS    0x0001
  404. #define EXT2_SF_BAD_INODE_BLK    0x0002
  405. #define EXT2_SF_BAD_EXTRA_BYTES    0x0004
  406. #define EXT2_SF_SKIP_MISSING_ITABLE    0x0008
  407. #define EXT2_SF_DO_LAZY        0x0010
  408.  
  409. /*
  410.  * ext2fs_check_if_mounted flags
  411.  */
  412. #define EXT2_MF_MOUNTED        1
  413. #define EXT2_MF_ISROOT        2
  414. #define EXT2_MF_READONLY    4
  415. #define EXT2_MF_SWAP        8
  416. #define EXT2_MF_BUSY        16
  417.  
  418. /*
  419.  * Ext2/linux mode flags.  We define them here so that we don't need
  420.  * to depend on the OS's sys/stat.h, since we may be compiling on a
  421.  * non-Linux system.
  422.  */
  423. #define LINUX_S_IFMT  00170000
  424. #define LINUX_S_IFSOCK 0140000
  425. #define LINUX_S_IFLNK     0120000
  426. #define LINUX_S_IFREG  0100000
  427. #define LINUX_S_IFBLK  0060000
  428. #define LINUX_S_IFDIR  0040000
  429. #define LINUX_S_IFCHR  0020000
  430. #define LINUX_S_IFIFO  0010000
  431. #define LINUX_S_ISUID  0004000
  432. #define LINUX_S_ISGID  0002000
  433. #define LINUX_S_ISVTX  0001000
  434.  
  435. #define LINUX_S_IRWXU 00700
  436. #define LINUX_S_IRUSR 00400
  437. #define LINUX_S_IWUSR 00200
  438. #define LINUX_S_IXUSR 00100
  439.  
  440. #define LINUX_S_IRWXG 00070
  441. #define LINUX_S_IRGRP 00040
  442. #define LINUX_S_IWGRP 00020
  443. #define LINUX_S_IXGRP 00010
  444.  
  445. #define LINUX_S_IRWXO 00007
  446. #define LINUX_S_IROTH 00004
  447. #define LINUX_S_IWOTH 00002
  448. #define LINUX_S_IXOTH 00001
  449.  
  450. #define LINUX_S_ISLNK(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFLNK)
  451. #define LINUX_S_ISREG(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFREG)
  452. #define LINUX_S_ISDIR(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFDIR)
  453. #define LINUX_S_ISCHR(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFCHR)
  454. #define LINUX_S_ISBLK(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFBLK)
  455. #define LINUX_S_ISFIFO(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFIFO)
  456. #define LINUX_S_ISSOCK(m)    (((m) & LINUX_S_IFMT) == LINUX_S_IFSOCK)
  457.  
  458. /*
  459.  * ext2 size of an inode
  460.  */
  461. #define EXT2_I_SIZE(i)    ((i)->i_size | ((__u64) (i)->i_size_high << 32))
  462.  
  463. /*
  464.  * ext2_icount_t abstraction
  465.  */
  466. #define EXT2_ICOUNT_OPT_INCREMENT    0x01
  467.  
  468. typedef struct ext2_icount *ext2_icount_t;
  469.  
  470. /*
  471.  * Flags for ext2fs_bmap
  472.  */
  473. #define BMAP_ALLOC    0x0001
  474. #define BMAP_SET    0x0002
  475.  
  476. /*
  477.  * Returned flags from ext2fs_bmap
  478.  */
  479. #define BMAP_RET_UNINIT    0x0001
  480.  
  481. /*
  482.  * Flags for imager.c functions
  483.  */
  484. #define IMAGER_FLAG_INODEMAP    1
  485. #define IMAGER_FLAG_SPARSEWRITE    2
  486.  
  487. /*
  488.  * For checking structure magic numbers...
  489.  */
  490.  
  491. #define EXT2_CHECK_MAGIC(struct, code) \
  492.       if ((struct)->magic != (code)) return (code)
  493.  
  494.  
  495. /*
  496.  * For ext2 compression support
  497.  */
  498. #define EXT2FS_COMPRESSED_BLKADDR ((blk_t) -1)
  499. #define HOLE_BLKADDR(_b) ((_b) == 0 || (_b) == EXT2FS_COMPRESSED_BLKADDR)
  500.  
  501. /*
  502.  * Features supported by this version of the library
  503.  */
  504. #define EXT2_LIB_FEATURE_COMPAT_SUPP    (EXT2_FEATURE_COMPAT_DIR_PREALLOC|\
  505.                      EXT2_FEATURE_COMPAT_IMAGIC_INODES|\
  506.                      EXT3_FEATURE_COMPAT_HAS_JOURNAL|\
  507.                      EXT2_FEATURE_COMPAT_RESIZE_INODE|\
  508.                      EXT2_FEATURE_COMPAT_DIR_INDEX|\
  509.                      EXT2_FEATURE_COMPAT_EXT_ATTR)
  510.  
  511. /* This #ifdef is temporary until compression is fully supported */
  512. #ifdef ENABLE_COMPRESSION
  513. #ifndef I_KNOW_THAT_COMPRESSION_IS_EXPERIMENTAL
  514. /* If the below warning bugs you, then have
  515.    `CPPFLAGS=-DI_KNOW_THAT_COMPRESSION_IS_EXPERIMENTAL' in your
  516.    environment at configure time. */
  517.  #warning "Compression support is experimental"
  518. #endif
  519. #define EXT2_LIB_FEATURE_INCOMPAT_SUPP    (EXT2_FEATURE_INCOMPAT_FILETYPE|\
  520.                      EXT2_FEATURE_INCOMPAT_COMPRESSION|\
  521.                      EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|\
  522.                      EXT2_FEATURE_INCOMPAT_META_BG|\
  523.                      EXT3_FEATURE_INCOMPAT_RECOVER|\
  524.                      EXT3_FEATURE_INCOMPAT_EXTENTS|\
  525.                      EXT4_FEATURE_INCOMPAT_FLEX_BG)
  526. #else
  527. #define EXT2_LIB_FEATURE_INCOMPAT_SUPP    (EXT2_FEATURE_INCOMPAT_FILETYPE|\
  528.                      EXT3_FEATURE_INCOMPAT_JOURNAL_DEV|\
  529.                      EXT2_FEATURE_INCOMPAT_META_BG|\
  530.                      EXT3_FEATURE_INCOMPAT_RECOVER|\
  531.                      EXT3_FEATURE_INCOMPAT_EXTENTS|\
  532.                      EXT4_FEATURE_INCOMPAT_FLEX_BG)
  533. #endif
  534. #define EXT2_LIB_FEATURE_RO_COMPAT_SUPP    (EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER|\
  535.                      EXT4_FEATURE_RO_COMPAT_HUGE_FILE|\
  536.                      EXT2_FEATURE_RO_COMPAT_LARGE_FILE|\
  537.                      EXT4_FEATURE_RO_COMPAT_DIR_NLINK|\
  538.                      EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE|\
  539.                      EXT4_FEATURE_RO_COMPAT_GDT_CSUM)
  540.  
  541. /*
  542.  * These features are only allowed if EXT2_FLAG_SOFTSUPP_FEATURES is passed
  543.  * to ext2fs_openfs()
  544.  */
  545. #define EXT2_LIB_SOFTSUPP_INCOMPAT    (0)
  546. #define EXT2_LIB_SOFTSUPP_RO_COMPAT    (0)
  547.  
  548. /*
  549.  * function prototypes
  550.  */
  551.  
  552. /* alloc.c */
  553. extern errcode_t ext2fs_new_inode(ext2_filsys fs, ext2_ino_t dir, int mode,
  554.                   ext2fs_inode_bitmap map, ext2_ino_t *ret);
  555. extern errcode_t ext2fs_new_block(ext2_filsys fs, blk_t goal,
  556.                   ext2fs_block_bitmap map, blk_t *ret);
  557. extern errcode_t ext2fs_get_free_blocks(ext2_filsys fs, blk_t start,
  558.                     blk_t finish, int num,
  559.                     ext2fs_block_bitmap map,
  560.                     blk_t *ret);
  561. extern errcode_t ext2fs_alloc_block(ext2_filsys fs, blk_t goal,
  562.                     char *block_buf, blk_t *ret);
  563. extern void ext2fs_set_alloc_block_callback(ext2_filsys fs,
  564.                         errcode_t (*func)(ext2_filsys fs,
  565.                                   blk64_t goal,
  566.                                   blk64_t *ret),
  567.                         errcode_t (**old)(ext2_filsys fs,
  568.                                   blk64_t goal,
  569.                                   blk64_t *ret));
  570.  
  571. /* alloc_sb.c */
  572. extern int ext2fs_reserve_super_and_bgd(ext2_filsys fs,
  573.                     dgrp_t group,
  574.                     ext2fs_block_bitmap bmap);
  575. extern void ext2fs_set_block_alloc_stats_callback(ext2_filsys fs,
  576.                           void (*func)(ext2_filsys fs,
  577.                                    blk64_t blk,
  578.                                    int inuse),
  579.                           void (**old)(ext2_filsys fs,
  580.                                    blk64_t blk,
  581.                                    int inuse));
  582.  
  583. /* alloc_stats.c */
  584. void ext2fs_inode_alloc_stats(ext2_filsys fs, ext2_ino_t ino, int inuse);
  585. void ext2fs_inode_alloc_stats2(ext2_filsys fs, ext2_ino_t ino,
  586.                    int inuse, int isdir);
  587. void ext2fs_block_alloc_stats(ext2_filsys fs, blk_t blk, int inuse);
  588.  
  589. /* alloc_tables.c */
  590. extern errcode_t ext2fs_allocate_tables(ext2_filsys fs);
  591. extern errcode_t ext2fs_allocate_group_table(ext2_filsys fs, dgrp_t group,
  592.                          ext2fs_block_bitmap bmap);
  593.  
  594. /* badblocks.c */
  595. extern errcode_t ext2fs_u32_list_create(ext2_u32_list *ret, int size);
  596. extern errcode_t ext2fs_u32_list_add(ext2_u32_list bb, __u32 blk);
  597. extern int ext2fs_u32_list_find(ext2_u32_list bb, __u32 blk);
  598. extern int ext2fs_u32_list_test(ext2_u32_list bb, blk_t blk);
  599. extern errcode_t ext2fs_u32_list_iterate_begin(ext2_u32_list bb,
  600.                            ext2_u32_iterate *ret);
  601. extern int ext2fs_u32_list_iterate(ext2_u32_iterate iter, blk_t *blk);
  602. extern void ext2fs_u32_list_iterate_end(ext2_u32_iterate iter);
  603. extern errcode_t ext2fs_u32_copy(ext2_u32_list src, ext2_u32_list *dest);
  604. extern int ext2fs_u32_list_equal(ext2_u32_list bb1, ext2_u32_list bb2);
  605.  
  606. extern errcode_t ext2fs_badblocks_list_create(ext2_badblocks_list *ret,
  607.                         int size);
  608. extern errcode_t ext2fs_badblocks_list_add(ext2_badblocks_list bb,
  609.                        blk_t blk);
  610. extern int ext2fs_badblocks_list_test(ext2_badblocks_list bb,
  611.                     blk_t blk);
  612. extern int ext2fs_u32_list_del(ext2_u32_list bb, __u32 blk);
  613. extern void ext2fs_badblocks_list_del(ext2_u32_list bb, __u32 blk);
  614. extern errcode_t
  615.     ext2fs_badblocks_list_iterate_begin(ext2_badblocks_list bb,
  616.                         ext2_badblocks_iterate *ret);
  617. extern int ext2fs_badblocks_list_iterate(ext2_badblocks_iterate iter,
  618.                      blk_t *blk);
  619. extern void ext2fs_badblocks_list_iterate_end(ext2_badblocks_iterate iter);
  620. extern errcode_t ext2fs_badblocks_copy(ext2_badblocks_list src,
  621.                        ext2_badblocks_list *dest);
  622. extern int ext2fs_badblocks_equal(ext2_badblocks_list bb1,
  623.                   ext2_badblocks_list bb2);
  624. extern int ext2fs_u32_list_count(ext2_u32_list bb);
  625.  
  626. /* bb_compat */
  627. extern errcode_t badblocks_list_create(badblocks_list *ret, int size);
  628. extern errcode_t badblocks_list_add(badblocks_list bb, blk_t blk);
  629. extern int badblocks_list_test(badblocks_list bb, blk_t blk);
  630. extern errcode_t badblocks_list_iterate_begin(badblocks_list bb,
  631.                           badblocks_iterate *ret);
  632. extern int badblocks_list_iterate(badblocks_iterate iter, blk_t *blk);
  633. extern void badblocks_list_iterate_end(badblocks_iterate iter);
  634. extern void badblocks_list_free(badblocks_list bb);
  635.  
  636. /* bb_inode.c */
  637. extern errcode_t ext2fs_update_bb_inode(ext2_filsys fs,
  638.                     ext2_badblocks_list bb_list);
  639.  
  640. /* bitmaps.c */
  641. extern void ext2fs_free_block_bitmap(ext2fs_block_bitmap bitmap);
  642. extern void ext2fs_free_inode_bitmap(ext2fs_inode_bitmap bitmap);
  643. extern errcode_t ext2fs_copy_bitmap(ext2fs_generic_bitmap src,
  644.                     ext2fs_generic_bitmap *dest);
  645. extern errcode_t ext2fs_write_inode_bitmap(ext2_filsys fs);
  646. extern errcode_t ext2fs_write_block_bitmap (ext2_filsys fs);
  647. extern errcode_t ext2fs_read_inode_bitmap (ext2_filsys fs);
  648. extern errcode_t ext2fs_read_block_bitmap(ext2_filsys fs);
  649. extern errcode_t ext2fs_allocate_block_bitmap(ext2_filsys fs,
  650.                           const char *descr,
  651.                           ext2fs_block_bitmap *ret);
  652. extern errcode_t ext2fs_allocate_inode_bitmap(ext2_filsys fs,
  653.                           const char *descr,
  654.                           ext2fs_inode_bitmap *ret);
  655. extern errcode_t ext2fs_fudge_inode_bitmap_end(ext2fs_inode_bitmap bitmap,
  656.                            ext2_ino_t end, ext2_ino_t *oend);
  657. extern errcode_t ext2fs_fudge_block_bitmap_end(ext2fs_block_bitmap bitmap,
  658.                            blk_t end, blk_t *oend);
  659. extern void ext2fs_clear_inode_bitmap(ext2fs_inode_bitmap bitmap);
  660. extern void ext2fs_clear_block_bitmap(ext2fs_block_bitmap bitmap);
  661. extern errcode_t ext2fs_read_bitmaps(ext2_filsys fs);
  662. extern errcode_t ext2fs_write_bitmaps(ext2_filsys fs);
  663. extern errcode_t ext2fs_resize_inode_bitmap(__u32 new_end, __u32 new_real_end,
  664.                         ext2fs_inode_bitmap bmap);
  665. extern errcode_t ext2fs_resize_block_bitmap(__u32 new_end, __u32 new_real_end,
  666.                         ext2fs_block_bitmap bmap);
  667. extern errcode_t ext2fs_compare_block_bitmap(ext2fs_block_bitmap bm1,
  668.                          ext2fs_block_bitmap bm2);
  669. extern errcode_t ext2fs_compare_inode_bitmap(ext2fs_inode_bitmap bm1,
  670.                          ext2fs_inode_bitmap bm2);
  671. extern errcode_t ext2fs_set_inode_bitmap_range(ext2fs_inode_bitmap bmap,
  672.                     ext2_ino_t start, unsigned int num,
  673.                     void *in);
  674. extern errcode_t ext2fs_get_inode_bitmap_range(ext2fs_inode_bitmap bmap,
  675.                     ext2_ino_t start, unsigned int num,
  676.                     void *out);
  677. extern errcode_t ext2fs_set_block_bitmap_range(ext2fs_block_bitmap bmap,
  678.                     blk_t start, unsigned int num,
  679.                     void *in);
  680. extern errcode_t ext2fs_get_block_bitmap_range(ext2fs_block_bitmap bmap,
  681.                     blk_t start, unsigned int num,
  682.                     void *out);
  683.  
  684.  
  685. /* block.c */
  686. extern errcode_t ext2fs_block_iterate(ext2_filsys fs,
  687.                       ext2_ino_t    ino,
  688.                       int    flags,
  689.                       char *block_buf,
  690.                       int (*func)(ext2_filsys fs,
  691.                           blk_t    *blocknr,
  692.                           int    blockcnt,
  693.                           void    *priv_data),
  694.                       void *priv_data);
  695. errcode_t ext2fs_block_iterate2(ext2_filsys fs,
  696.                 ext2_ino_t    ino,
  697.                 int    flags,
  698.                 char *block_buf,
  699.                 int (*func)(ext2_filsys fs,
  700.                         blk_t    *blocknr,
  701.                         e2_blkcnt_t    blockcnt,
  702.                         blk_t    ref_blk,
  703.                         int        ref_offset,
  704.                         void    *priv_data),
  705.                 void *priv_data);
  706.  
  707. /* bmap.c */
  708. extern errcode_t ext2fs_bmap(ext2_filsys fs, ext2_ino_t ino,
  709.                  struct ext2_inode *inode,
  710.                  char *block_buf, int bmap_flags,
  711.                  blk_t block, blk_t *phys_blk);
  712. extern errcode_t ext2fs_bmap2(ext2_filsys fs, ext2_ino_t ino,
  713.                   struct ext2_inode *inode,
  714.                   char *block_buf, int bmap_flags, blk64_t block,
  715.                   int *ret_flags, blk64_t *phys_blk);
  716.  
  717. #if 0
  718. /* bmove.c */
  719. extern errcode_t ext2fs_move_blocks(ext2_filsys fs,
  720.                     ext2fs_block_bitmap reserve,
  721.                     ext2fs_block_bitmap alloc_map,
  722.                     int flags);
  723. #endif
  724.  
  725. /* check_desc.c */
  726. extern errcode_t ext2fs_check_desc(ext2_filsys fs);
  727.  
  728. /* closefs.c */
  729. extern errcode_t ext2fs_close(ext2_filsys fs);
  730. extern errcode_t ext2fs_flush(ext2_filsys fs);
  731. extern int ext2fs_bg_has_super(ext2_filsys fs, int group_block);
  732. extern int ext2fs_super_and_bgd_loc(ext2_filsys fs,
  733.                     dgrp_t group,
  734.                     blk_t *ret_super_blk,
  735.                     blk_t *ret_old_desc_blk,
  736.                     blk_t *ret_new_desc_blk,
  737.                     int *ret_meta_bg);
  738. extern void ext2fs_update_dynamic_rev(ext2_filsys fs);
  739.  
  740. /* csum.c */
  741. extern void ext2fs_group_desc_csum_set(ext2_filsys fs, dgrp_t group);
  742. extern int ext2fs_group_desc_csum_verify(ext2_filsys fs, dgrp_t group);
  743. extern errcode_t ext2fs_set_gdt_csum(ext2_filsys fs);
  744.  
  745. /* dblist.c */
  746.  
  747. extern errcode_t ext2fs_get_num_dirs(ext2_filsys fs, ext2_ino_t *ret_num_dirs);
  748. extern errcode_t ext2fs_init_dblist(ext2_filsys fs, ext2_dblist *ret_dblist);
  749. extern errcode_t ext2fs_add_dir_block(ext2_dblist dblist, ext2_ino_t ino,
  750.                       blk_t blk, int blockcnt);
  751. extern void ext2fs_dblist_sort(ext2_dblist dblist,
  752.                    EXT2_QSORT_TYPE (*sortfunc)(const void *,
  753.                                const void *));
  754. extern errcode_t ext2fs_dblist_iterate(ext2_dblist dblist,
  755.     int (*func)(ext2_filsys fs, struct ext2_db_entry *db_info,
  756.             void    *priv_data),
  757.        void *priv_data);
  758. extern errcode_t ext2fs_set_dir_block(ext2_dblist dblist, ext2_ino_t ino,
  759.                       blk_t blk, int blockcnt);
  760. extern errcode_t ext2fs_copy_dblist(ext2_dblist src,
  761.                     ext2_dblist *dest);
  762. extern int ext2fs_dblist_count(ext2_dblist dblist);
  763. extern errcode_t ext2fs_dblist_get_last(ext2_dblist dblist,
  764.                     struct ext2_db_entry **entry);
  765. extern errcode_t ext2fs_dblist_drop_last(ext2_dblist dblist);
  766.  
  767. /* dblist_dir.c */
  768. extern errcode_t
  769.     ext2fs_dblist_dir_iterate(ext2_dblist dblist,
  770.                   int    flags,
  771.                   char    *block_buf,
  772.                   int (*func)(ext2_ino_t    dir,
  773.                           int        entry,
  774.                           struct ext2_dir_entry *dirent,
  775.                           int    offset,
  776.                           int    blocksize,
  777.                           char    *buf,
  778.                           void    *priv_data),
  779.                   void *priv_data);
  780.  
  781. /* dirblock.c */
  782. extern errcode_t ext2fs_read_dir_block(ext2_filsys fs, blk_t block,
  783.                        void *buf);
  784. extern errcode_t ext2fs_read_dir_block2(ext2_filsys fs, blk_t block,
  785.                     void *buf, int flags);
  786. extern errcode_t ext2fs_write_dir_block(ext2_filsys fs, blk_t block,
  787.                     void *buf);
  788. extern errcode_t ext2fs_write_dir_block2(ext2_filsys fs, blk_t block,
  789.                      void *buf, int flags);
  790.  
  791. /* dirhash.c */
  792. extern errcode_t ext2fs_dirhash(int version, const char *name, int len,
  793.                 const __u32 *seed,
  794.                 ext2_dirhash_t *ret_hash,
  795.                 ext2_dirhash_t *ret_minor_hash);
  796.  
  797.  
  798. /* dir_iterate.c */
  799. extern errcode_t ext2fs_dir_iterate(ext2_filsys fs,
  800.                   ext2_ino_t dir,
  801.                   int flags,
  802.                   char *block_buf,
  803.                   int (*func)(struct ext2_dir_entry *dirent,
  804.                       int    offset,
  805.                       int    blocksize,
  806.                       char    *buf,
  807.                       void    *priv_data),
  808.                   void *priv_data);
  809. extern errcode_t ext2fs_dir_iterate2(ext2_filsys fs,
  810.                   ext2_ino_t dir,
  811.                   int flags,
  812.                   char *block_buf,
  813.                   int (*func)(ext2_ino_t    dir,
  814.                       int    entry,
  815.                       struct ext2_dir_entry *dirent,
  816.                       int    offset,
  817.                       int    blocksize,
  818.                       char    *buf,
  819.                       void    *priv_data),
  820.                   void *priv_data);
  821.  
  822. /* dupfs.c */
  823. extern errcode_t ext2fs_dup_handle(ext2_filsys src, ext2_filsys *dest);
  824.  
  825. /* expanddir.c */
  826. extern errcode_t ext2fs_expand_dir(ext2_filsys fs, ext2_ino_t dir);
  827.  
  828. /* ext_attr.c */
  829. extern __u32 ext2fs_ext_attr_hash_entry(struct ext2_ext_attr_entry *entry,
  830.                     void *data);
  831. extern errcode_t ext2fs_read_ext_attr(ext2_filsys fs, blk_t block, void *buf);
  832. extern errcode_t ext2fs_write_ext_attr(ext2_filsys fs, blk_t block,
  833.                        void *buf);
  834. extern errcode_t ext2fs_adjust_ea_refcount(ext2_filsys fs, blk_t blk,
  835.                        char *block_buf,
  836.                        int adjust, __u32 *newcount);
  837.  
  838. /* extent.c */
  839. extern errcode_t ext2fs_extent_header_verify(void *ptr, int size);
  840. extern errcode_t ext2fs_extent_open(ext2_filsys fs, ext2_ino_t ino,
  841.                     ext2_extent_handle_t *handle);
  842. extern void ext2fs_extent_free(ext2_extent_handle_t handle);
  843. extern errcode_t ext2fs_extent_get(ext2_extent_handle_t handle,
  844.                    int flags, struct ext2fs_extent *extent);
  845. extern errcode_t ext2fs_extent_replace(ext2_extent_handle_t handle, int flags,
  846.                        struct ext2fs_extent *extent);
  847. extern errcode_t ext2fs_extent_insert(ext2_extent_handle_t handle, int flags,
  848.                       struct ext2fs_extent *extent);
  849. extern errcode_t ext2fs_extent_set_bmap(ext2_extent_handle_t handle,
  850.                     blk64_t logical, blk64_t physical,
  851.                     int flags);
  852. extern errcode_t ext2fs_extent_delete(ext2_extent_handle_t handle, int flags);
  853. extern errcode_t ext2fs_extent_get_info(ext2_extent_handle_t handle,
  854.                     struct ext2_extent_info *info);
  855. extern errcode_t ext2fs_extent_goto(ext2_extent_handle_t handle,
  856.                     blk64_t blk);
  857.  
  858. /* fileio.c */
  859. extern errcode_t ext2fs_file_open2(ext2_filsys fs, ext2_ino_t ino,
  860.                    struct ext2_inode *inode,
  861.                    int flags, ext2_file_t *ret);
  862. extern errcode_t ext2fs_file_open(ext2_filsys fs, ext2_ino_t ino,
  863.                   int flags, ext2_file_t *ret);
  864. extern ext2_filsys ext2fs_file_get_fs(ext2_file_t file);
  865. extern errcode_t ext2fs_file_close(ext2_file_t file);
  866. extern errcode_t ext2fs_file_flush(ext2_file_t file);
  867. extern errcode_t ext2fs_file_read(ext2_file_t file, void *buf,
  868.                   unsigned int wanted, unsigned int *got);
  869. extern errcode_t ext2fs_file_write(ext2_file_t file, const void *buf,
  870.                    unsigned int nbytes, unsigned int *written);
  871. extern errcode_t ext2fs_file_llseek(ext2_file_t file, __u64 offset,
  872.                    int whence, __u64 *ret_pos);
  873. extern errcode_t ext2fs_file_lseek(ext2_file_t file, ext2_off_t offset,
  874.                    int whence, ext2_off_t *ret_pos);
  875. errcode_t ext2fs_file_get_lsize(ext2_file_t file, __u64 *ret_size);
  876. extern ext2_off_t ext2fs_file_get_size(ext2_file_t file);
  877. extern errcode_t ext2fs_file_set_size(ext2_file_t file, ext2_off_t size);
  878.  
  879. /* finddev.c */
  880. extern char *ext2fs_find_block_device(dev_t device);
  881.  
  882. /* flushb.c */
  883. extern errcode_t ext2fs_sync_device(int fd, int flushb);
  884.  
  885. /* freefs.c */
  886. extern void ext2fs_free(ext2_filsys fs);
  887. extern void ext2fs_free_dblist(ext2_dblist dblist);
  888. extern void ext2fs_badblocks_list_free(ext2_badblocks_list bb);
  889. extern void ext2fs_u32_list_free(ext2_u32_list bb);
  890.  
  891. /* gen_bitmap.c */
  892. extern void ext2fs_free_generic_bitmap(ext2fs_inode_bitmap bitmap);
  893. extern errcode_t ext2fs_make_generic_bitmap(errcode_t magic, ext2_filsys fs,
  894.                         __u32 start, __u32 end,
  895.                         __u32 real_end,
  896.                         const char *descr, char *init_map,
  897.                         ext2fs_generic_bitmap *ret);
  898. extern errcode_t ext2fs_allocate_generic_bitmap(__u32 start,
  899.                         __u32 end,
  900.                         __u32 real_end,
  901.                         const char *descr,
  902.                         ext2fs_generic_bitmap *ret);
  903. extern errcode_t ext2fs_copy_generic_bitmap(ext2fs_generic_bitmap src,
  904.                         ext2fs_generic_bitmap *dest);
  905. extern void ext2fs_clear_generic_bitmap(ext2fs_generic_bitmap bitmap);
  906. extern errcode_t ext2fs_fudge_generic_bitmap_end(ext2fs_inode_bitmap bitmap,
  907.                          errcode_t magic,
  908.                          errcode_t neq,
  909.                          ext2_ino_t end,
  910.                          ext2_ino_t *oend);
  911. extern void ext2fs_set_generic_bitmap_padding(ext2fs_generic_bitmap map);
  912. extern errcode_t ext2fs_resize_generic_bitmap(errcode_t magic,
  913.                           __u32 new_end,
  914.                           __u32 new_real_end,
  915.                           ext2fs_generic_bitmap bmap);
  916. extern errcode_t ext2fs_compare_generic_bitmap(errcode_t magic, errcode_t neq,
  917.                            ext2fs_generic_bitmap bm1,
  918.                            ext2fs_generic_bitmap bm2);
  919. extern errcode_t ext2fs_get_generic_bitmap_range(ext2fs_generic_bitmap bmap,
  920.                          errcode_t magic,
  921.                          __u32 start, __u32 num,
  922.                          void *out);
  923. extern errcode_t ext2fs_set_generic_bitmap_range(ext2fs_generic_bitmap bmap,
  924.                          errcode_t magic,
  925.                          __u32 start, __u32 num,
  926.                          void *in);
  927.  
  928. /* getsize.c */
  929. extern errcode_t ext2fs_get_device_size(const char *file, int blocksize,
  930.                     blk_t *retblocks);
  931.  
  932. /* getsectsize.c */
  933. errcode_t ext2fs_get_device_sectsize(const char *file, int *sectsize);
  934.  
  935. /* i_block.c */
  936. errcode_t ext2fs_iblk_add_blocks(ext2_filsys fs, struct ext2_inode *inode,
  937.                  blk64_t num_blocks);
  938. errcode_t ext2fs_iblk_sub_blocks(ext2_filsys fs, struct ext2_inode *inode,
  939.                  blk64_t num_blocks);
  940. errcode_t ext2fs_iblk_set(ext2_filsys fs, struct ext2_inode *inode, blk64_t b);
  941.  
  942. /* imager.c */
  943. extern errcode_t ext2fs_image_inode_write(ext2_filsys fs, int fd, int flags);
  944. extern errcode_t ext2fs_image_inode_read(ext2_filsys fs, int fd, int flags);
  945. extern errcode_t ext2fs_image_super_write(ext2_filsys fs, int fd, int flags);
  946. extern errcode_t ext2fs_image_super_read(ext2_filsys fs, int fd, int flags);
  947. extern errcode_t ext2fs_image_bitmap_write(ext2_filsys fs, int fd, int flags);
  948. extern errcode_t ext2fs_image_bitmap_read(ext2_filsys fs, int fd, int flags);
  949.  
  950. /* ind_block.c */
  951. errcode_t ext2fs_read_ind_block(ext2_filsys fs, blk_t blk, void *buf);
  952. errcode_t ext2fs_write_ind_block(ext2_filsys fs, blk_t blk, void *buf);
  953.  
  954. /* initialize.c */
  955. extern errcode_t ext2fs_initialize(const char *name, int flags,
  956.                    struct ext2_super_block *param,
  957.                    io_manager manager, ext2_filsys *ret_fs);
  958.  
  959. /* icount.c */
  960. extern void ext2fs_free_icount(ext2_icount_t icount);
  961. extern errcode_t ext2fs_create_icount_tdb(ext2_filsys fs, char *tdb_dir,
  962.                       int flags, ext2_icount_t *ret);
  963. extern errcode_t ext2fs_create_icount2(ext2_filsys fs, int flags,
  964.                        unsigned int size,
  965.                        ext2_icount_t hint, ext2_icount_t *ret);
  966. extern errcode_t ext2fs_create_icount(ext2_filsys fs, int flags,
  967.                       unsigned int size,
  968.                       ext2_icount_t *ret);
  969. extern errcode_t ext2fs_icount_fetch(ext2_icount_t icount, ext2_ino_t ino,
  970.                      __u16 *ret);
  971. extern errcode_t ext2fs_icount_increment(ext2_icount_t icount, ext2_ino_t ino,
  972.                      __u16 *ret);
  973. extern errcode_t ext2fs_icount_decrement(ext2_icount_t icount, ext2_ino_t ino,
  974.                      __u16 *ret);
  975. extern errcode_t ext2fs_icount_store(ext2_icount_t icount, ext2_ino_t ino,
  976.                      __u16 count);
  977. extern ext2_ino_t ext2fs_get_icount_size(ext2_icount_t icount);
  978. errcode_t ext2fs_icount_validate(ext2_icount_t icount, FILE *);
  979.  
  980. /* inode.c */
  981. extern errcode_t ext2fs_flush_icache(ext2_filsys fs);
  982. extern errcode_t ext2fs_get_next_inode_full(ext2_inode_scan scan,
  983.                         ext2_ino_t *ino,
  984.                         struct ext2_inode *inode,
  985.                         int bufsize);
  986. extern errcode_t ext2fs_open_inode_scan(ext2_filsys fs, int buffer_blocks,
  987.                   ext2_inode_scan *ret_scan);
  988. extern void ext2fs_close_inode_scan(ext2_inode_scan scan);
  989. extern errcode_t ext2fs_get_next_inode(ext2_inode_scan scan, ext2_ino_t *ino,
  990.                    struct ext2_inode *inode);
  991. extern errcode_t ext2fs_inode_scan_goto_blockgroup(ext2_inode_scan scan,
  992.                            int    group);
  993. extern void ext2fs_set_inode_callback
  994.     (ext2_inode_scan scan,
  995.      errcode_t (*done_group)(ext2_filsys fs,
  996.                  ext2_inode_scan scan,
  997.                  dgrp_t group,
  998.                  void * priv_data),
  999.      void *done_group_data);
  1000. extern int ext2fs_inode_scan_flags(ext2_inode_scan scan, int set_flags,
  1001.                    int clear_flags);
  1002. extern errcode_t ext2fs_read_inode_full(ext2_filsys fs, ext2_ino_t ino,
  1003.                     struct ext2_inode * inode,
  1004.                     int bufsize);
  1005. extern errcode_t ext2fs_read_inode (ext2_filsys fs, ext2_ino_t ino,
  1006.                 struct ext2_inode * inode);
  1007. extern errcode_t ext2fs_write_inode_full(ext2_filsys fs, ext2_ino_t ino,
  1008.                      struct ext2_inode * inode,
  1009.                      int bufsize);
  1010. extern errcode_t ext2fs_write_inode(ext2_filsys fs, ext2_ino_t ino,
  1011.                 struct ext2_inode * inode);
  1012. extern errcode_t ext2fs_write_new_inode(ext2_filsys fs, ext2_ino_t ino,
  1013.                 struct ext2_inode * inode);
  1014. extern errcode_t ext2fs_get_blocks(ext2_filsys fs, ext2_ino_t ino, blk_t *blocks);
  1015. extern errcode_t ext2fs_check_directory(ext2_filsys fs, ext2_ino_t ino);
  1016.  
  1017. /* inode_io.c */
  1018. extern io_manager inode_io_manager;
  1019. extern errcode_t ext2fs_inode_io_intern(ext2_filsys fs, ext2_ino_t ino,
  1020.                     char **name);
  1021. extern errcode_t ext2fs_inode_io_intern2(ext2_filsys fs, ext2_ino_t ino,
  1022.                      struct ext2_inode *inode,
  1023.                      char **name);
  1024.  
  1025. /* ismounted.c */
  1026. extern errcode_t ext2fs_check_if_mounted(const char *file, int *mount_flags);
  1027. extern errcode_t ext2fs_check_mount_point(const char *device, int *mount_flags,
  1028.                       char *mtpt, int mtlen);
  1029.  
  1030. /* namei.c */
  1031. extern errcode_t ext2fs_lookup(ext2_filsys fs, ext2_ino_t dir, const char *name,
  1032.              int namelen, char *buf, ext2_ino_t *inode);
  1033. extern errcode_t ext2fs_namei(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
  1034.             const char *name, ext2_ino_t *inode);
  1035. errcode_t ext2fs_namei_follow(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
  1036.                   const char *name, ext2_ino_t *inode);
  1037. extern errcode_t ext2fs_follow_link(ext2_filsys fs, ext2_ino_t root, ext2_ino_t cwd,
  1038.             ext2_ino_t inode, ext2_ino_t *res_inode);
  1039.  
  1040. /* native.c */
  1041. int ext2fs_native_flag(void);
  1042.  
  1043. /* newdir.c */
  1044. extern errcode_t ext2fs_new_dir_block(ext2_filsys fs, ext2_ino_t dir_ino,
  1045.                 ext2_ino_t parent_ino, char **block);
  1046.  
  1047. /* mkdir.c */
  1048. extern errcode_t ext2fs_mkdir(ext2_filsys fs, ext2_ino_t parent, ext2_ino_t inum,
  1049.                   const char *name);
  1050.  
  1051. /* mkjournal.c */
  1052. extern errcode_t ext2fs_zero_blocks(ext2_filsys fs, blk_t blk, int num,
  1053.                     blk_t *ret_blk, int *ret_count);
  1054. extern errcode_t ext2fs_create_journal_superblock(ext2_filsys fs,
  1055.                           __u32 size, int flags,
  1056.                           char  **ret_jsb);
  1057. extern errcode_t ext2fs_add_journal_device(ext2_filsys fs,
  1058.                        ext2_filsys journal_dev);
  1059. extern errcode_t ext2fs_add_journal_inode(ext2_filsys fs, blk_t size,
  1060.                       int flags);
  1061. extern int ext2fs_default_journal_size(__u64 blocks);
  1062.  
  1063. /* openfs.c */
  1064. extern errcode_t ext2fs_open(const char *name, int flags, int superblock,
  1065.                  unsigned int block_size, io_manager manager,
  1066.                  ext2_filsys *ret_fs);
  1067. extern errcode_t ext2fs_open2(const char *name, const char *io_options,
  1068.                   int flags, int superblock,
  1069.                   unsigned int block_size, io_manager manager,
  1070.                   ext2_filsys *ret_fs);
  1071. extern blk_t ext2fs_descriptor_block_loc(ext2_filsys fs, blk_t group_block,
  1072.                      dgrp_t i);
  1073. errcode_t ext2fs_get_data_io(ext2_filsys fs, io_channel *old_io);
  1074. errcode_t ext2fs_set_data_io(ext2_filsys fs, io_channel new_io);
  1075. errcode_t ext2fs_rewrite_to_io(ext2_filsys fs, io_channel new_io);
  1076.  
  1077. /* get_pathname.c */
  1078. extern errcode_t ext2fs_get_pathname(ext2_filsys fs, ext2_ino_t dir, ext2_ino_t ino,
  1079.                    char **name);
  1080.  
  1081. /* link.c */
  1082. errcode_t ext2fs_link(ext2_filsys fs, ext2_ino_t dir, const char *name,
  1083.               ext2_ino_t ino, int flags);
  1084. errcode_t ext2fs_unlink(ext2_filsys fs, ext2_ino_t dir, const char *name,
  1085.             ext2_ino_t ino, int flags);
  1086.  
  1087. /* read_bb.c */
  1088. extern errcode_t ext2fs_read_bb_inode(ext2_filsys fs,
  1089.                       ext2_badblocks_list *bb_list);
  1090.  
  1091. /* read_bb_file.c */
  1092. extern errcode_t ext2fs_read_bb_FILE2(ext2_filsys fs, FILE *f,
  1093.                       ext2_badblocks_list *bb_list,
  1094.                       void *priv_data,
  1095.                       void (*invalid)(ext2_filsys fs,
  1096.                               blk_t blk,
  1097.                               char *badstr,
  1098.                               void *priv_data));
  1099. extern errcode_t ext2fs_read_bb_FILE(ext2_filsys fs, FILE *f,
  1100.                      ext2_badblocks_list *bb_list,
  1101.                      void (*invalid)(ext2_filsys fs,
  1102.                              blk_t blk));
  1103.  
  1104. /* res_gdt.c */
  1105. extern errcode_t ext2fs_create_resize_inode(ext2_filsys fs);
  1106.  
  1107. /* swapfs.c */
  1108. extern void ext2fs_swap_ext_attr(char *to, char *from, int bufsize,
  1109.                  int has_header);
  1110. extern void ext2fs_swap_ext_attr_header(struct ext2_ext_attr_header *to_header,
  1111.                     struct ext2_ext_attr_header *from_hdr);
  1112. extern void ext2fs_swap_ext_attr_entry(struct ext2_ext_attr_entry *to_entry,
  1113.                        struct ext2_ext_attr_entry *from_entry);
  1114. extern void ext2fs_swap_super(struct ext2_super_block * super);
  1115. extern void ext2fs_swap_group_desc(struct ext2_group_desc *gdp);
  1116. extern void ext2fs_swap_inode_full(ext2_filsys fs, struct ext2_inode_large *t,
  1117.                    struct ext2_inode_large *f, int hostorder,
  1118.                    int bufsize);
  1119. extern void ext2fs_swap_inode(ext2_filsys fs,struct ext2_inode *t,
  1120.                   struct ext2_inode *f, int hostorder);
  1121.  
  1122. /* valid_blk.c */
  1123. extern int ext2fs_inode_has_valid_blocks(struct ext2_inode *inode);
  1124.  
  1125. /* version.c */
  1126. extern int ext2fs_parse_version_string(const char *ver_string);
  1127. extern int ext2fs_get_library_version(const char **ver_string,
  1128.                       const char **date_string);
  1129.  
  1130. /* write_bb_file.c */
  1131. extern errcode_t ext2fs_write_bb_FILE(ext2_badblocks_list bb_list,
  1132.                       unsigned int flags,
  1133.                       FILE *f);
  1134.  
  1135.  
  1136. /* inline functions */
  1137. extern errcode_t ext2fs_get_mem(unsigned long size, void *ptr);
  1138. extern errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr);
  1139. extern errcode_t ext2fs_free_mem(void *ptr);
  1140. extern errcode_t ext2fs_resize_mem(unsigned long old_size,
  1141.                    unsigned long size, void *ptr);
  1142. extern void ext2fs_mark_super_dirty(ext2_filsys fs);
  1143. extern void ext2fs_mark_changed(ext2_filsys fs);
  1144. extern int ext2fs_test_changed(ext2_filsys fs);
  1145. extern void ext2fs_mark_valid(ext2_filsys fs);
  1146. extern void ext2fs_unmark_valid(ext2_filsys fs);
  1147. extern int ext2fs_test_valid(ext2_filsys fs);
  1148. extern void ext2fs_mark_ib_dirty(ext2_filsys fs);
  1149. extern void ext2fs_mark_bb_dirty(ext2_filsys fs);
  1150. extern int ext2fs_test_ib_dirty(ext2_filsys fs);
  1151. extern int ext2fs_test_bb_dirty(ext2_filsys fs);
  1152. extern int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk);
  1153. extern int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino);
  1154. extern blk_t ext2fs_group_first_block(ext2_filsys fs, dgrp_t group);
  1155. extern blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group);
  1156. extern blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
  1157.                       struct ext2_inode *inode);
  1158. extern unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b);
  1159.  
  1160. /*
  1161.  * The actual inlined functions definitions themselves...
  1162.  *
  1163.  * If NO_INLINE_FUNCS is defined, then we won't try to do inline
  1164.  * functions at all!
  1165.  */
  1166. #if (defined(INCLUDE_INLINE_FUNCS) || !defined(NO_INLINE_FUNCS))
  1167. #ifdef INCLUDE_INLINE_FUNCS
  1168. #define _INLINE_ extern
  1169. #else
  1170. #ifdef __GNUC__
  1171. #define _INLINE_ extern __inline__
  1172. #else                /* For Watcom C */
  1173. #define _INLINE_ extern inline
  1174. #endif
  1175. #endif
  1176.  
  1177. #ifndef EXT2_CUSTOM_MEMORY_ROUTINES
  1178. #include <string.h>
  1179. /*
  1180.  *  Allocate memory
  1181.  */
  1182. _INLINE_ errcode_t ext2fs_get_mem(unsigned long size, void *ptr)
  1183. {
  1184.     void *pp;
  1185.  
  1186.     pp = malloc(size);
  1187.     if (!pp)
  1188.         return EXT2_ET_NO_MEMORY;
  1189.     memcpy(ptr, &pp, sizeof (pp));
  1190.     return 0;
  1191. }
  1192.  
  1193. _INLINE_ errcode_t ext2fs_get_array(unsigned long count, unsigned long size, void *ptr)
  1194. {
  1195.     if (count && (-1UL)/count<size)
  1196.         return EXT2_ET_NO_MEMORY; //maybe define EXT2_ET_OVERFLOW ?
  1197.     return ext2fs_get_mem(count*size, ptr);
  1198. }
  1199.  
  1200. /*
  1201.  * Free memory
  1202.  */
  1203. _INLINE_ errcode_t ext2fs_free_mem(void *ptr)
  1204. {
  1205.     void *p;
  1206.  
  1207.     memcpy(&p, ptr, sizeof(p));
  1208.     free(p);
  1209.     p = 0;
  1210.     memcpy(ptr, &p, sizeof(p));
  1211.     return 0;
  1212. }
  1213.  
  1214. /*
  1215.  *  Resize memory
  1216.  */
  1217. _INLINE_ errcode_t ext2fs_resize_mem(unsigned long EXT2FS_ATTR((unused)) old_size,
  1218.                      unsigned long size, void *ptr)
  1219. {
  1220.     void *p;
  1221.  
  1222.     /* Use "memcpy" for pointer assignments here to avoid problems
  1223.      * with C99 strict type aliasing rules. */
  1224.     memcpy(&p, ptr, sizeof(p));
  1225.     p = realloc(p, size);
  1226.     if (!p)
  1227.         return EXT2_ET_NO_MEMORY;
  1228.     memcpy(ptr, &p, sizeof(p));
  1229.     return 0;
  1230. }
  1231. #endif    /* Custom memory routines */
  1232.  
  1233. /*
  1234.  * Mark a filesystem superblock as dirty
  1235.  */
  1236. _INLINE_ void ext2fs_mark_super_dirty(ext2_filsys fs)
  1237. {
  1238.     fs->flags |= EXT2_FLAG_DIRTY | EXT2_FLAG_CHANGED;
  1239. }
  1240.  
  1241. /*
  1242.  * Mark a filesystem as changed
  1243.  */
  1244. _INLINE_ void ext2fs_mark_changed(ext2_filsys fs)
  1245. {
  1246.     fs->flags |= EXT2_FLAG_CHANGED;
  1247. }
  1248.  
  1249. /*
  1250.  * Check to see if a filesystem has changed
  1251.  */
  1252. _INLINE_ int ext2fs_test_changed(ext2_filsys fs)
  1253. {
  1254.     return (fs->flags & EXT2_FLAG_CHANGED);
  1255. }
  1256.  
  1257. /*
  1258.  * Mark a filesystem as valid
  1259.  */
  1260. _INLINE_ void ext2fs_mark_valid(ext2_filsys fs)
  1261. {
  1262.     fs->flags |= EXT2_FLAG_VALID;
  1263. }
  1264.  
  1265. /*
  1266.  * Mark a filesystem as NOT valid
  1267.  */
  1268. _INLINE_ void ext2fs_unmark_valid(ext2_filsys fs)
  1269. {
  1270.     fs->flags &= ~EXT2_FLAG_VALID;
  1271. }
  1272.  
  1273. /*
  1274.  * Check to see if a filesystem is valid
  1275.  */
  1276. _INLINE_ int ext2fs_test_valid(ext2_filsys fs)
  1277. {
  1278.     return (fs->flags & EXT2_FLAG_VALID);
  1279. }
  1280.  
  1281. /*
  1282.  * Mark the inode bitmap as dirty
  1283.  */
  1284. _INLINE_ void ext2fs_mark_ib_dirty(ext2_filsys fs)
  1285. {
  1286.     fs->flags |= EXT2_FLAG_IB_DIRTY | EXT2_FLAG_CHANGED;
  1287. }
  1288.  
  1289. /*
  1290.  * Mark the block bitmap as dirty
  1291.  */
  1292. _INLINE_ void ext2fs_mark_bb_dirty(ext2_filsys fs)
  1293. {
  1294.     fs->flags |= EXT2_FLAG_BB_DIRTY | EXT2_FLAG_CHANGED;
  1295. }
  1296.  
  1297. /*
  1298.  * Check to see if a filesystem's inode bitmap is dirty
  1299.  */
  1300. _INLINE_ int ext2fs_test_ib_dirty(ext2_filsys fs)
  1301. {
  1302.     return (fs->flags & EXT2_FLAG_IB_DIRTY);
  1303. }
  1304.  
  1305. /*
  1306.  * Check to see if a filesystem's block bitmap is dirty
  1307.  */
  1308. _INLINE_ int ext2fs_test_bb_dirty(ext2_filsys fs)
  1309. {
  1310.     return (fs->flags & EXT2_FLAG_BB_DIRTY);
  1311. }
  1312.  
  1313. /*
  1314.  * Return the group # of a block
  1315.  */
  1316. _INLINE_ int ext2fs_group_of_blk(ext2_filsys fs, blk_t blk)
  1317. {
  1318.     return (blk - fs->super->s_first_data_block) /
  1319.         fs->super->s_blocks_per_group;
  1320. }
  1321.  
  1322. /*
  1323.  * Return the group # of an inode number
  1324.  */
  1325. _INLINE_ int ext2fs_group_of_ino(ext2_filsys fs, ext2_ino_t ino)
  1326. {
  1327.     return (ino - 1) / fs->super->s_inodes_per_group;
  1328. }
  1329.  
  1330. /*
  1331.  * Return the first block (inclusive) in a group
  1332.  */
  1333. _INLINE_ blk_t ext2fs_group_first_block(ext2_filsys fs, dgrp_t group)
  1334. {
  1335.     return fs->super->s_first_data_block +
  1336.         (group * fs->super->s_blocks_per_group);
  1337. }
  1338.  
  1339. /*
  1340.  * Return the last block (inclusive) in a group
  1341.  */
  1342. _INLINE_ blk_t ext2fs_group_last_block(ext2_filsys fs, dgrp_t group)
  1343. {
  1344.     return (group == fs->group_desc_count - 1 ?
  1345.         fs->super->s_blocks_count - 1 :
  1346.         ext2fs_group_first_block(fs, group) +
  1347.             (fs->super->s_blocks_per_group - 1));
  1348. }
  1349.  
  1350. _INLINE_ blk_t ext2fs_inode_data_blocks(ext2_filsys fs,
  1351.                     struct ext2_inode *inode)
  1352. {
  1353.        return inode->i_blocks -
  1354.               (inode->i_file_acl ? fs->blocksize >> 9 : 0);
  1355. }
  1356.  
  1357. /*
  1358.  * This is an efficient, overflow safe way of calculating ceil((1.0 * a) / b)
  1359.  */
  1360. _INLINE_ unsigned int ext2fs_div_ceil(unsigned int a, unsigned int b)
  1361. {
  1362.     if (!a)
  1363.         return 0;
  1364.     return ((a - 1) / b) + 1;
  1365. }
  1366. #undef _INLINE_
  1367. #endif
  1368.  
  1369. #ifdef __cplusplus
  1370. }
  1371. #endif
  1372.  
  1373. #endif /* _EXT2FS_EXT2FS_H */
  1374.